package com.cn.wanxi.util;

public class MyHelp {
    /**
     * 2021-6-4 file类
     * 1.封装  怎么通过生活中的例子封装到Java  file
     * 2.构造方法  得到对象
     * 3.重载？重构？区别？
     * 4.File 类里面其他方法
     * 5.递归
     * 6.创建文件夹  mkdir  mkdirs
     * 7.删除
     * 8.创建文件
     * 9.得到文件路径（数组）listFiles();
     *
     */
    /**
     * 2021-6-7 io流思路
     * 1.接口的目的 实现多态
     * 2.思路
     *      1）创建文件
     *      2）写入数据（将dao层数据封装到list，因为写入数据时代码重复率太高）
     *      3）读取数据（字符流和字节流的区别？）
     *      4）封装数据（拿到读取出来的结果进行封装)
     * 注意：一个方法里面只做一件事情，如果有其他代码，则应该提取出去单独写方法
     */
    /**
     * 2021-6-8  第二阶段内容总结
     * 第二阶段：要求：将当前项目按照面向对象的形式，把说有数据提取出来，放到dao层，然后通过servlet+jsp的框架模式渲染到页面
     * 面向对象
     *      1）封装
     *      2）多态--继承
     *      3）如果要封装对象？我们需要找到对象？怎么找到对象？什么才叫对象？
     *      4）对象：不参合其他对象，将对象拆分成最小单位
     *      5）对象需要有属性和方法：这个属性和方法必须是当前对象的
     *      6）一个对象--一个model--一个service--对应一个dao
     *      7）一个页面对应一个servlet
     *      8）注意：对象应该是独立，应该是完整，应该是不可分割
     * 数据提取   将页面数据进行剪切赋值到dao
     * dao层
     * servlet+jsp
     *      1）页面转发---跳转到页面
     *      2）需要数据--将最终封装好的数据存入到作用域（request），然后转发到页面
     *      3）数据在哪个地方来？service--
     *      ---------------------
     *      4）jsp里面就是渲染数据
     *              1）对象  ${对象.属性}，这里的对象这个值对应的是servlet里面的key值
     *              2）数组，集合    forEach     item里面${key} var=model   循环数据里面的对象
     *              3）${model.属性}
     *  --------------------------------------------
     *  对象和对象之间的关系？
     *  继承
     *  实现
     *  依赖
     *  聚合  弱关系
     *  组合  关系更强，不可风格
     */
    /**
     * 2021-6-8 集合或者数组的io
     * 第三阶段需求：将数据转换到记事本，所以只需要在service里面修改代码即可
     * 1.servlet  服务逻辑层需要修改成接口的形式
     * 2.service  需要提供一个接口，和一个实现类
     *      1）需要创建文件和文件夹（需要返回一个文件类型）
     *      2）封装需要写入的数据，因为写数据的时候需要将数据转换为byte字节
     *      3）写入数据   需要得到第一步文件
     *      4）读取数据
     *              字符和字节流
     *               String 和 StringBuilding和StringBuffer的区别？
     *      5）封装数据
     *              replace 替换
     *              split 将字符串转换为数组
     * 3.对于创建文件，读取数据，写入数据的代码和任何一个service里面的对象无关，
     * 所以将代码提起到工具类里面
     */
    /**
     * 2021-6-9 IO流工具类的封装
     * 1.常量类
     * 2.枚举类
     * 3.对service的再次封装（就是将所有关于IO的部分全部封装到工具类）
     * 4.当前类只能写自己的方法和属性（不能有关于其他任何类的封装）
     * 5.如果有其他类，则不符合Java的特点（低耦合，高内聚）
     * 6.如果a类操作了b类的数据，一般情况下我们会传一个对象（引用传递）（高耦合）
     * 7.类与类之间的关系（依赖关系）弱依赖，以提高开发效率
     * 8.面向对象开发（各封装各的，不要发生强关系)
     * 重点 ：遵循---高内聚和低耦合
     */
    /**
     * 2021-6-11
     * 第一阶段：
     * 项目开发流程（周期）
     * 1）项目确立
     * 2）需求分析 概要需求分析  详细需求分析  主要是为了下面的原型图
     * 3）画原型图---画页面
     * 4）UI设计师  画页面（图片）
     * 5）web端页面（web工程师，div+css+flex）
     * 6）数据库设计（数据库工程师）
     * 7）项目架构设计（架构师）
     * 8）程序员代码开发 89K
     * 9）项目测试---34K45K8K
     * 10)项目交互
     * 11）维护---
     * 码云   ---版本控制
     * div    盒子   外边距，内边距  边框
     * css    选择器  元素选择器（标签选择器） 类选择器  后代选择器 兄弟选择器 子选择器
     *        line-height 行高  （字体）上下对齐
     *        height
     *        width
     *        weight  字体的粗细
     *        background-color
     *        background-image
     *        color
     *        font
     *        溢出--只要有文字的地方 都要涉及到(多保险)
     *        content  改变img地址
     *        animation 动画
     *        百度地图
     *        contenteditable
     *        cursor
     *
     * flex
     *      display：flex
     *      justify-content: center;
     *      align-items: center;
     *      flex-wrap: wrap;
     * 第二阶段：
     * 类和对象
     * Java的特点
     * Java的特征 继承 封装  多态
     * 类 的组成部分？
     * 包  全小写  如果有多个不一样的意思 则直接新建包 com.cn.wanxi.util
     * 类名
     * 属性
     * 方法
     * 构造方法
     * 命名规范？
     *      类名   大驼峰  FindByUsernameAndPassword
     *      属性名 小驼峰
     *      参数名、成员变量、局部变量  小驼峰
     *      方法名 小驼峰   findByUsernameAndPassword
     *      常量名 全大写  如果有多个单词  下划线 FILE_NAME_NEWS_FOR_HOME_PAGE
     *      枚举名  classEnum
     *      接口名  IClass     UserService为后缀  UserDao
     *      实现类    impl结尾
     *      抽象类名  AbstractClass 或者BaseClass
     *      异常类   ClassException
     * 属性：一个完整定义属性
     * 权限修饰符
     *      private
     *      public
     *      protected
     *      默认不写
     * 特征修饰符
     *      static
     *      final
     *      synchronized
     *      native
     * 数据类型
     *      基本类型
     *          整型
     *          浮点型
     *          字符型
     *          布尔型
     *          取值范围--默认值--字节数
     *          向上（向下）转型   自动转换（强制转换）
     *      引用类型
     *          类  接口  枚举   注解  （只要是大写的）
     *          强引用   在整个生命周期 都存在 都不会被GC（垃圾回收器）回收
     *          弱引用   如果内存大于100%（满了） 就会回收
     *          软引用   被发现了（专业的人）  就会回收
     *          虚引用   被发现了（随便什么人发现）  就会回收
     * 变量名
     * = 赋值运算符  （从右向左读） int  a=1；
     * 字面量   值
     *
     * 方法：
     * 一个完整的方法：一点一点删除
     * public static  String  getName(String name) throw Exception{
     *
     *     System.out.println(1);
     *     return "aa";
     * }
     * 构造方法
     * 代码块
     * 静态代码块
     * 加载顺序？  静态代码块--代码块--构造方法
     * 类与类之间的关系？
     *
     *
     * 泛化  -继承，实现（夸张功能）都要抽象出一个父类
     *      base，abstract，i 对应的子类必须完善父类的功能
     * 依赖  - 以引用类型作为参数进行传递
     *      Service   service=new ServiceImpl();
     *      UserModel userModel=new UserModel();
     *      service.add(userModel);
     * 关联  -聚合（可分割），组合（不可分割）   强弱关系   包含关系
     * -------------------------------------------------------------------
     * 做项目----servlet+jsp
     * 1）将html转换为jsp
     * 2）后台：三层架构
     *      页面控制层   servlet
     *      服务逻辑层   service
     *      数据实现层   dao
     *
     *      实体层  model
     *      工具层  util
     *
     *      将页面按照面向对象的形式将数据放到数据层并通过jsp渲染到页面
     *      1）将页面封装到对象（分解成对象）（最小原则，不能再次分解（原子性））
     *      2）每个对象之间不错存在强关系  （低耦合高内聚）
     *      3）一个页面对象对应一个model  （包含属性  ）
     *      4）一个model对应一个dao，对应一个service
     *      5）一个servlet对应一个页面
     *      6）一个页面对应多个对象
     *      7）在servlet 分别拿到相对于的值
     *  写代码：倒推法（servlet页面控制层）
     *      1）访问后台---地址（注解）
     *      2）方法  所有的数据进行展示等于查询后台（get）
     *      3）页面转发（重定向）需要将数据转发到jsp页面
     *      4）四大作用域  容器 request  key-value
     *      5）数据在哪里来？ service服务逻辑层
     *      service服务逻辑层
     *      1）先定义一个空的返回值对象
     *      2）封装返回值对象
     *      3）里面的值从dao层来
     *      dao 数据实现层
     *      1）对于对象 直接对属性进行赋值
     *      2）对于数组或者集合  也是直接赋值
     * 注意：对于jsp   要取得后台的值  ${}
     *      forEach    items=${key}    var="model"    varStatus   begin  end   step
     * 第三阶段：io流
     *      File类    通过生活中的对象  去封装file类
     *      String path="";
     *      String fileName="";
     *      File file=new File();//构造方法
     *      1）String path，String fileName
     *      2）String path
     *      3）File path，String fileName
     *      创建文件夹
     *       exists
     *       mkdirs  mkdir
     *       创建文件
     *       createNewFile
     *       增刪查改的操作 对文件
     *       --------------
     *       对文件内容的操作   输入输出流
     *       输出流 OutputStream outputStream=new FileOutputStream();
     *       抽象类和接口不能进行实例化操作
     *       outputStream.write();
     *       int  将int和char进行转换  汉字和字符的字节数？
     *       bytes  字符串怎么转换为byte数组
     *       ---------------------
     *       做项目：思路 要把数据存到记事本 所有的数据来源与记事本
     *          1）根据给定的路径创建文件和文件夹（返回文件）
     *          1.5） 必须将数据进行封装
     *          2）写入数据（输出流）
     *          3）读取数据（输入流)必须得到读取的结果，返回值
     *          4）封装成对于的对象或者集合
     *      ------------------------
     *      IO工具类的封装
     *      所有关于io的代码  都不能出现在service层  ，只能去调用
     *      toString()
     *      equals()
     *      split()
     *      replace()
     *      Arrays.toString();
     *      --------------------
     *      常量类
     *      枚举类
     *
     */

}
